/**
 * 通用工具函数
 */

/**
 * 格式化日期时间
 * @param {string|Date} time - 时间字符串或日期对象
 * @param {string} format - 格式化模板，默认为'YYYY-MM-DD HH:mm'
 * @returns {string} 格式化后的时间字符串
 */
export const formatDateTime = (time, format = 'YYYY-MM-DD HH:mm') => {
  if (!time) return '';
  
  const date = new Date(time);
  
  const formatMap = {
    'YYYY': date.getFullYear(),
    'MM': (date.getMonth() + 1).toString().padStart(2, '0'),
    'DD': date.getDate().toString().padStart(2, '0'),
    'HH': date.getHours().toString().padStart(2, '0'),
    'mm': date.getMinutes().toString().padStart(2, '0'),
    'ss': date.getSeconds().toString().padStart(2, '0')
  };
  
  return format.replace(/YYYY|MM|DD|HH|mm|ss/g, match => formatMap[match]);
};

/**
 * 格式化相对时间（几分钟前、几小时前等）
 * @param {string|Date} time - 时间字符串或日期对象
 * @returns {string} 相对时间描述
 */
export const formatRelativeTime = (time) => {
  if (!time) return '';
  
  const now = new Date();
  const targetTime = new Date(time);
  const diffMinutes = Math.floor((now - targetTime) / (1000 * 60));
  
  if (diffMinutes < 1) {
    return '刚刚';
  } else if (diffMinutes < 60) {
    return `${diffMinutes}分钟前`;
  } else if (diffMinutes < 24 * 60) {
    return `${Math.floor(diffMinutes / 60)}小时前`;
  } else if (diffMinutes < 30 * 24 * 60) {
    return `${Math.floor(diffMinutes / (24 * 60))}天前`;
  } else {
    return formatDateTime(targetTime, 'YYYY-MM-DD');
  }
};

/**
 * 格式化时间为"多久前"的形式
 * @param {number|string|Date} timestamp - 时间戳、时间字符串或日期对象
 * @returns {string} 格式化后的时间
 */
export const formatTimeAgo = (timestamp) => {
  if (!timestamp) return '';
  
  const now = new Date().getTime();
  const time = new Date(timestamp).getTime();
  const diff = now - time;
  
  // 转换为秒
  const seconds = Math.floor(diff / 1000);
  
  if (seconds < 60) {
    return '刚刚';
  }
  
  // 转换为分钟
  const minutes = Math.floor(seconds / 60);
  if (minutes < 60) {
    return `${minutes}分钟前`;
  }
  
  // 转换为小时
  const hours = Math.floor(minutes / 60);
  if (hours < 24) {
    return `${hours}小时前`;
  }
  
  // 转换为天
  const days = Math.floor(hours / 24);
  if (days < 30) {
    return `${days}天前`;
  }
  
  // 转换为月
  const months = Math.floor(days / 30);
  if (months < 12) {
    return `${months}个月前`;
  }
  
  // 转换为年
  const years = Math.floor(months / 12);
  return `${years}年前`;
};

/**
 * 上传图片
 * @param {Object} options - 上传选项
 * @param {string} options.sourceType - 图片来源类型：'album'(相册),'camera'(相机),'both'(两者)
 * @param {number} options.count - 最多可选择的图片数量
 * @param {boolean} options.compress - 是否压缩图片
 * @returns {Promise} 返回上传结果的Promise
 */
export const uploadImage = ({
  sourceType = 'both',
  count = 1,
  compress = true
} = {}) => {
  // 转换sourceType参数
  let sourceTypeArray = [];
  if (sourceType === 'album' || sourceType === 'both') {
    sourceTypeArray.push('album');
  }
  if (sourceType === 'camera' || sourceType === 'both') {
    sourceTypeArray.push('camera');
  }
  
  return new Promise((resolve, reject) => {
    // 选择图片
    uni.chooseImage({
      count,
      sourceType: sourceTypeArray,
      success: (chooseRes) => {
        const tempFilePaths = chooseRes.tempFilePaths;
        
        // 如果不需要压缩，直接上传
        if (!compress) {
          uploadToServer(tempFilePaths[0])
            .then(resolve)
            .catch(reject);
          return;
        }
        
        // 压缩图片
        uni.compressImage({
          src: tempFilePaths[0],
          quality: 80,
          success: (compressRes) => {
            uploadToServer(compressRes.tempFilePath)
              .then(resolve)
              .catch(reject);
          },
          fail: (err) => {
            console.error('压缩图片失败', err);
            // 压缩失败，使用原图上传
            uploadToServer(tempFilePaths[0])
              .then(resolve)
              .catch(reject);
          }
        });
      },
      fail: (err) => {
        console.error('选择图片失败', err);
        reject(err);
      }
    });
  });
};

/**
 * 上传图片到服务器
 * @param {string} filePath - 本地文件路径
 * @returns {Promise} 返回上传结果的Promise
 */
const uploadToServer = (filePath) => {
  return new Promise((resolve, reject) => {
    uni.showLoading({
      title: '上传中...'
    });
    
    uni.uploadFile({
      url: 'http://localhost:8080/api/image/upload', // 实际项目中替换为真实的上传地址
      filePath,
      name: 'file',
      success: (uploadRes) => {
        uni.hideLoading();
        
        // 解析返回的JSON数据
        try {
          const data = JSON.parse(uploadRes.data);
          if (data.code === 0) {
            resolve(data.data);
          } else {
            uni.showToast({
              title: data.message || '上传失败',
              icon: 'none'
            });
            reject(new Error(data.message || '上传失败'));
          }
        } catch (e) {
          uni.showToast({
            title: '上传失败，服务器返回数据格式错误',
            icon: 'none'
          });
          reject(new Error('上传失败，服务器返回数据格式错误'));
        }
      },
      fail: (err) => {
        uni.hideLoading();
        uni.showToast({
          title: '上传失败，请检查网络',
          icon: 'none'
        });
        console.error('上传失败', err);
        reject(err);
      }
    });
  });
};

/**
 * 保存图片到相册
 * @param {string} url - 图片URL
 * @returns {Promise} 返回保存结果的Promise
 */
export const saveImageToAlbum = (url) => {
  return new Promise((resolve, reject) => {
    uni.showLoading({
      title: '保存中...'
    });
    
    // 如果是网络图片，先下载
    if (url.startsWith('http')) {
      uni.downloadFile({
        url,
        success: (res) => {
          if (res.statusCode === 200) {
            saveFile(res.tempFilePath)
              .then(resolve)
              .catch(reject);
          } else {
            uni.hideLoading();
            uni.showToast({
              title: '下载图片失败',
              icon: 'none'
            });
            reject(new Error('下载图片失败'));
          }
        },
        fail: (err) => {
          uni.hideLoading();
          uni.showToast({
            title: '下载图片失败',
            icon: 'none'
          });
          console.error('下载图片失败', err);
          reject(err);
        }
      });
    } else {
      // 本地图片直接保存
      saveFile(url)
        .then(resolve)
        .catch(reject);
    }
  });
};

/**
 * 保存文件到相册
 * @param {string} filePath - 本地文件路径
 * @returns {Promise} 返回保存结果的Promise
 */
const saveFile = (filePath) => {
  return new Promise((resolve, reject) => {
    uni.saveImageToPhotosAlbum({
      filePath,
      success: () => {
        uni.hideLoading();
        uni.showToast({
          title: '已保存到相册',
          icon: 'success'
        });
        resolve();
      },
      fail: (err) => {
        uni.hideLoading();
        
        // 如果是用户拒绝授权导致的失败
        if (err.errMsg.indexOf('auth deny') >= 0) {
          uni.showModal({
            title: '提示',
            content: '需要您授权保存图片到相册',
            confirmText: '去设置',
            cancelText: '取消',
            success: (res) => {
              if (res.confirm) {
                uni.openSetting();
              }
            }
          });
        } else {
          uni.showToast({
            title: '保存失败',
            icon: 'none'
          });
        }
        
        console.error('保存到相册失败', err);
        reject(err);
      }
    });
  });
};

/**
 * 生成分享海报
 * @param {Object} params - 分享参数
 * @returns {Promise} 返回海报URL的Promise
 */
export const generateSharePoster = (params) => {
  return new Promise((resolve, reject) => {
    uni.showLoading({
      title: '生成海报中...'
    });
    
    // 实际项目中应该调用后端API
    uni.request({
      url: 'http://localhost:8080/api/feed/share',
      method: 'POST',
      data: params,
      success: (res) => {
        uni.hideLoading();
        
        if (res.data.code === 0) {
          resolve(res.data.data.posterUrl);
        } else {
          uni.showToast({
            title: res.data.message || '生成海报失败',
            icon: 'none'
          });
          reject(new Error(res.data.message || '生成海报失败'));
        }
      },
      fail: (err) => {
        uni.hideLoading();
        uni.showToast({
          title: '生成海报失败，请检查网络',
          icon: 'none'
        });
        console.error('生成海报失败', err);
        reject(err);
      }
    });
  });
};

/**
 * 截断文本
 * @param {string} text - 原始文本
 * @param {number} length - 最大长度
 * @returns {string} 截断后的文本
 */
export const truncateText = (text, length = 50) => {
  if (!text) return '';
  return text.length > length ? text.substring(0, length) + '...' : text;
};

/**
 * 获取随机颜色
 * @returns {string} 十六进制颜色值
 */
export const getRandomColor = () => {
  const colors = [
    '#FF69B4', // 粉红色
    '#FF8C69', // 浅珊瑚色
    '#FFC0CB', // 粉色
    '#FFB6C1', // 浅粉色
    '#FFA07A', // 浅鲑鱼色
    '#FF7F50', // 珊瑚色
    '#FF6347', // 番茄色
    '#FF4500', // 橙红色
    '#FF8C00', // 深橙色
    '#FFA500'  // 橙色
  ];
  return colors[Math.floor(Math.random() * colors.length)];
};

/**
 * 检查网络状态
 * @returns {Promise} 返回网络状态的Promise
 */
export const checkNetworkStatus = () => {
  return new Promise((resolve) => {
    uni.getNetworkType({
      success: (res) => {
        resolve(res.networkType !== 'none');
      },
      fail: () => {
        resolve(false);
      }
    });
  });
};

/**
 * 防抖函数
 * @param {Function} fn - 需要防抖的函数
 * @param {number} delay - 延迟时间，单位毫秒
 * @returns {Function} 防抖后的函数
 */
export const debounce = (fn, delay = 300) => {
  let timer = null;
  return function(...args) {
    if (timer) clearTimeout(timer);
    timer = setTimeout(() => {
      fn.apply(this, args);
    }, delay);
  };
};

/**
 * 节流函数
 * @param {Function} fn - 需要节流的函数
 * @param {number} delay - 延迟时间，单位毫秒
 * @returns {Function} 节流后的函数
 */
export const throttle = (fn, delay = 300) => {
  let lastCall = 0;
  return function(...args) {
    const now = Date.now();
    if (now - lastCall < delay) return;
    lastCall = now;
    fn.apply(this, args);
  };
};
